/**
 * Software License, Version 1.0
 *
 * Copyright 2003 The Trustees of Indiana University.  All rights reserved.
 *
 *
 *Redistribution and use in source and binary forms, with or without
 *modification, are permitted provided that the following conditions are met:
 *
 *1) All redistributions of source code must retain the above copyright notice,
 * the list of authors in the original source code, this list of conditions and
 * the disclaimer listed in this license;
 *2) All redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the disclaimer listed in this license in
 * the documentation and/or other materials provided with the distribution;
 *3) Any documentation included with all redistributions must include the
 * following acknowledgement:
 *
 *"This product includes software developed by the Community Grids Lab. For
 * further information contact the Community Grids Lab at
 * http://communitygrids.iu.edu/."
 *
 * Alternatively, this acknowledgement may appear in the software itself, and
 * wherever such third-party acknowledgments normally appear.
 *
 *4) The name Indiana University or Community Grids Lab or NaradaBrokering,
 * shall not be used to endorse or promote products derived from this software
 * without prior written permission from Indiana University.  For written
 * permission, please contact the Advanced Research and Technology Institute
 * ("ARTI") at 351 West 10th Street, Indianapolis, Indiana 46202.
 *5) Products derived from this software may not be called NaradaBrokering,
 * nor may Indiana University or Community Grids Lab or NaradaBrokering appear
 * in their name, without prior written permission of ARTI.
 *
 *
 * Indiana University provides no reassurances that the source code provided
 * does not infringe the patent or any other intellectual property rights of
 * any other entity.  Indiana University disclaims any liability to any
 * recipient for claims brought by any other entity based on infringement of
 * intellectual property rights or otherwise.
 *
 *LICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED "AS IS" FOR WHICH NO
 *WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA UNIVERSITY GIVES
 *NO WARRANTIES AND MAKES NO REPRESENTATION THAT SOFTWARE IS FREE OF
 *INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR OTHER PROPRIETARY RIGHTS.
 *INDIANA UNIVERSITY MAKES NO WARRANTIES THAT SOFTWARE IS FREE FROM "BUGS",
 *"VIRUSES", "TROJAN HORSES", "TRAP DOORS", "WORMS", OR OTHER HARMFUL CODE.
 *LICENSEE ASSUMES THE ENTIRE RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR
 *ASSOCIATED MATERIALS, AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION
 *GENERATED USING SOFTWARE.
 */
package cgl.narada.service.reliable;

import cgl.narada.event.NBEvent;
import cgl.narada.event.TemplateInfo;
import cgl.narada.matching.Profile;
import cgl.narada.service.ServiceException;
import cgl.narada.service.reliable.events.RdAckInvoiceEntityEvent;
import cgl.narada.service.reliable.events.RdCompanionEntityEvent;
import cgl.narada.service.reliable.events.RdNakInvoiceEntityEvent;
import cgl.narada.service.reliable.events.RdProfileUpdateRequest;
import cgl.narada.service.reliable.events.RdRecoveryEntityRequest;
import cgl.narada.service.reliable.events.RdRepublishedEntityEvent;

/** This class provides a set of core functions that service implementations
    need to satisfy. All services within the system need to conform to this
    interface.

    This class pertains to the reliable delivery service being provided to
    entities within the system. The service is responsible for among other
    things
    (a) Maintain the list of registered entities
    (b) Load the appropriate matching engines, depending upon the type of
    templates being managed.
    (c) Store events received onto stable storage.
    (d) Manage invoice events and ensure efficient negotiations with
    publishing entities.

    @author Shrideep Pallickara and Hasan Bulut
    $Date$
    $Revision$
*/

public interface ReliableDeliveryService {

  public void registerEntity(int entityId) throws ServiceException;

  /** Removes an entity from the list of registered entities. Also for every
      template id cycle through the entity list and remove the entity if
      present */
  public void deRegisterEntity(int entityId) throws ServiceException;


  /** Create a templateInfo */
  public TemplateInfo createTemplateInfo(int templateId, int templateType,
					 Object template)
    throws ServiceException;

  /** Add template management */
  public void addTemplateManagement(TemplateInfo templateInfo)
    throws ServiceException;

  /** Remove template management */
  public void removeTemplateManagement(int templateId)
    throws ServiceException;

  /** Returns a array containing the list of managed templates */
  public TemplateInfo[] getListOfManagedTemplates();


  /** Registers an entity with a managed template. */
  public void registerEntityForTemplate(int entityId,
					int templateId)
    throws ServiceException;


  /** Deregister's an entity from a managed template */
  public void deregisterEntityFromTemplate(int entityId,
					   int templateId)
    throws ServiceException;


  /** Process a profile update request */
  public void
  processProfileUpdateRequest(RdProfileUpdateRequest profileUpdateRequest)
    throws ServiceException;

  /** Add a profile */
  public void addProfile(int templateId, Profile profile)
    throws ServiceException;

  /* Remove a profile */
  public void removeProfile(int templateId, Profile profile)
    throws ServiceException;


  /** Processes an ACK invoice event received from an entity */
  public void processAckInvoiceEvent(RdAckInvoiceEntityEvent ackInvoiceEvent)
    throws ServiceException;

  /** Processes an nak invoice event received from an entity */
  public void processNakInvoiceEvent(RdNakInvoiceEntityEvent nakInvoiceEvent)
    throws ServiceException;


  /** Processes a published event received from an entity */
  public void processPublishedEvent(NBEvent nbEvent);

  /** Processes a companion event received for a previously published event */
  public void processCompanionEvent(RdCompanionEntityEvent companionEvent);

  /* Process a republished event */
  public void
  processRepublishedEvent(RdRepublishedEntityEvent republishedEvent);


  /* Process an entity recovery request */
  public void
  processEntityRecoveryRequest(RdRecoveryEntityRequest recoveryRequest);


  /** Proceed to store an event onto Storage */
  public void storeEventToStorage(NBEvent nbEvent)
     throws ServiceException;


  /** This method is invoked the first time a stable storage starts up,
      which might be after a failure or after a prolonged shutdown. This
      method enables the storage to recover from failures etc. */
  public void recoverFromFailure() throws ServiceException;

  public CompanionDbInfo getCompanionDbInfo(int templateId);

}



